Automated User Interface Generator

ABSTRACT

A user interface may be selected for a system with hierarchical data types by traversing an inheritance tree to find a pre-defined user interface, or by automatically generating a user interface based on the type definition. The automatically generated user interface may include tabs or groupings for components of the data type that may be inherited from other data types. In some embodiments, portions of the automatically generated user interface may be obtained from other data types.

BACKGROUND

Large scale applications, such as computer monitoring systems, may havemany different data types. The data types may be complex data types thatmay be created for displaying instances of the data types, as well assoliciting information from a user. In some such applications, there maybe many hundreds of data types, each of which may have a different userinterface.

SUMMARY

A user interface may be selected for a system with hierarchical datatypes by traversing an inheritance tree to find a pre-defined userinterface, or by automatically generating a user interface based on thetype definition. The automatically generated user interface may includetabs or groupings for components of the data type that may be inheritedfrom other data types. In some embodiments, portions of theautomatically generated user interface may be obtained from other datatypes.

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

In the drawings,

FIG. 1 is a diagram illustration of an embodiment showing a system withan automated user interface generator.

FIG. 2 is a flowchart illustration of an embodiment showing a method forcreating a user interface.

FIG. 3 is a flowchart illustration of an embodiment showing a method forpresenting a populated user interface.

FIG. 4 is a diagram illustration of an embodiment showing an example ofhierarchical data types.

FIG. 5 is a diagram illustration of an embodiment showing an example ofa first user interface.

FIG. 6 is a diagram illustration of an embodiment showing an example ofa second user interface.

DETAILED DESCRIPTION

A user interface may be created based on a hierarchical data typedefinition for an item. The hierarchical data type definition mayinclude properties that may be inherited between different items, and aswell as various annotations that may be used to create a user interface.The annotations may include descriptors, default values, and otherinformation.

A user interface may be created by attempting to find a predefined userinterface that may be associated with a selected data type. If a userinterface exists for the data type, that user interface may be used. Ifno user interface is defined for the data type, the hierarchical datatype definition may be traversed to find a predefined user interface foranother data type. The differences between the two data types may beidentified and a user interface may be built from the predefined userinterface along with an automated user interface for those differences.

The automated user interface generator may be useful for applicationswhere many different data types exist or where a user may be able toextend a data type. Rather than creating custom user interfaces for eachdata type, several predefined user interfaces may be created and theautomated user interface generator may customize the predefined userinterface to adapt to each specific data type. With a user-extendabledata type, the user-added elements may be added to an existing userinterface automatically.

Throughout this specification, like reference numbers signify the sameelements throughout the description of the figures.

When elements are referred to as being “connected” or “coupled,” theelements can be directly connected or coupled together or one or moreintervening elements may also be present. In contrast, when elements arereferred to as being “directly connected” or “directly coupled,” thereare no intervening elements present.

The subject matter may be embodied as devices, systems, methods, and/orcomputer program products. Accordingly, some or all of the subjectmatter may be embodied in hardware and/or in software (includingfirmware, resident software, micro-code, state machines, gate arrays,etc.) Furthermore, the subject matter may take the form of a computerprogram product on a computer-usable or computer-readable storage mediumhaving computer-usable or computer-readable program code embodied in themedium for use by or in connection with an instruction execution system.In the context of this document, a computer-usable or computer-readablemedium may be any medium that can contain, store, communicate,propagate, or transport the program for use by or in connection with theinstruction execution system, apparatus, or device.

The computer-usable or computer-readable medium may be for example, butnot limited to, an electronic, magnetic, optical, electromagnetic,infrared, or semiconductor system, apparatus, device, or propagationmedium. By way of example, and not limitation, computer-readable mediamay comprise computer storage media and communication media.

Computer storage media includes volatile and nonvolatile, removable andnon-removable media implemented in any method or technology for storageof information such as computer-readable instructions, data structures,program modules, or other data. Computer storage media includes, but isnot limited to, RAM, ROM, EEPROM, flash memory or other memorytechnology, CD-ROM, digital versatile disks (DVD) or other opticalstorage, magnetic cassettes, magnetic tape, magnetic disk storage orother magnetic storage devices, or any other medium which can be used tostore the desired information and may be accessed by an instructionexecution system. Note that the computer-usable or computer-readablemedium can be paper or other suitable medium upon which the program isprinted, as the program can be electronically captured via, forinstance, optical scanning of the paper or other suitable medium, thencompiled, interpreted, of otherwise processed in a suitable manner, ifnecessary, and then stored in a computer memory.

Communication media typically embodies computer-readable instructions,data structures, program modules or other data in a modulated datasignal such as a carrier wave or other transport mechanism and includesany information delivery media. The term “modulated data signal” can bedefined as a signal that has one or more of its characteristics set orchanged in such a manner as to encode information in the signal. By wayof example, and not limitation, communication media includes wired mediasuch as a wired network or direct-wired connection, and wireless mediasuch as acoustic, RF, infrared and other wireless media. Combinations ofany of the above-mentioned should also be included within the scope ofcomputer-readable media.

When the subject matter is embodied in the general context ofcomputer-executable instructions, the embodiment may comprise programmodules, executed by one or more systems, computers, or other devices.Generally, program modules include routines, programs, objects,components, data structures, and the like, that perform particular tasksor implement particular abstract data types. Typically, thefunctionality of the program modules may be combined or distributed asdesired in various embodiments.

FIG. 1 is a diagram of an embodiment 100, showing a system with anautomated user interface generator. Embodiment 100 is a simplifiedexample of a system that may have an application which may automaticallygenerate a user interface based on a hierarchical type definition.

The diagram of FIG. 1 illustrates functional components of a system. Insome cases, the component may be a hardware component, a softwarecomponent, or a combination of hardware and software. Some of thecomponents may be application level software, while other components maybe operating system level components. In some cases, the connection ofone component to another may be a close connection where two or morecomponents are operating on a single hardware platform. In other cases,the connections may be made over network connections spanning longdistances. Each embodiment may use different hardware, software, andinterconnection architectures to achieve the described functions.

Embodiment 100 is an example of an application that may use an annotatedhierarchical data type definition to automatically generate userinterfaces. The application may use other predefined user interfaces asbuilding blocks on which to construct a customized user interface, andthe predefined user interfaces may be selected based on the hierarchicaldata type definition.

In many applications, complex data types may be created to describeelements being manipulated. For example, an application may monitorvarious client computers, collect data from the client computers, createand manage help desk tickets, and issue work orders for technicians toexecute. Such a system may have many different data types arranged in ahierarchical fashion.

In the example, a base class may be defined as a device. Several datatypes may be instances of the device class, and one of which may be acomputer. For the computer data type, several types may be defined thatinherit the properties of the computer type and the device class. Onesuch type may be a server computer. From the server computer, severalmore data types may be defined for different types of operating systems,and from those data types, data types may be defined for differentversions of the operating system.

In the example, a large number of data types may be defined, and eachdata type may contain one or more elements that are associated with thedata type. Each element may be a parameter for which a value may or maynot be defined.

The device 102 may represent a conventional computing device on which anapplication may execute. The device 102 may have hardware components 104and software components 106 that may represent a conventional desktop orserver computer. The device 102 may be any type of computing device,such as a desktop or server computer, game console, network appliance,or other similar device. In some embodiments, the device 102 may be aportable device, such as a laptop or netbook computer, personal digitalassistant, mobile telephone, or other device. While not illustrated inembodiment 100, some embodiments may be deployed using cloud computingtechnologies that may or may not have a notion of a hardware platform onwhich an application may execute.

The hardware components 104 may include a processor 108, which mayaccess random access memory 110 and nonvolatile memory 112. The hardwarecomponents 106 may include a network interface 114 and a user interface116. The user interface 116 may include display devices 118 and inputdevices 120.

The software components 106 may include an operating system 112 on whichan application 124 may execute. The application 124 may have anautomated user interface generator 126 that may read an annotatedhierarchical data type definition 128 and may generate user interface,such as a data collection user interface 136 or a data display userinterface 138.

The annotated hierarchical data type definition 128 may include ahierarchical data type 130 that may include annotations 132 anddescription strings 134. In some embodiments, the entire data typedefinition 128 may be defined in a single file, such as an XML file. Inother embodiments, portions of the data type definition 128 may bedefined in separate files which may or may not use different formats andprotocols.

The hierarchical data type 130 may define a set of data types in ahierarchical fashion. A hierarchical definition may allow properties ofa higher class or data type to be inherited by lower data types.

When automatically generating a user interface, the hierarchy may beused in several different manners. In one manner, the hierarchy mayallow elements in a graphical user interface to be grouped or segregatedaccording to the hierarchy. Examples of such grouping may be shown inembodiments 500 and 600 presented later in this specification.

In another manner, the hierarchy may be used to locate a predefined userinterface that may be used to build a customized user interface for aselected type for which a predefined user interface does not exist. Thehierarchy may be traversed up or down from a given data type to identifya predefined user interface. From the predefined user interface,additional elements associated with the selected type may be presentedin an automatically generated section of the user interface.

The automatic user interface generator may allow a set of data types tobe extended. For example, an application may allow a user to add newparameters or elements to a given data type. The additional elements maynot have been known or even considered when the application and its userinterfaces were created, but the user interface generator 126 maygenerate an extension to an existing user interface and present thoseelements to a user.

The annotations 132 may include metadata about the various elements.When defined in some XML embodiments, the annotations 132 may beincluded as various tagged items associated with elements in a datatype. The annotations 132 may include an element name, a descriptivename, a help prompt, default values, value ranges, value options, andmany other metadata. In some embodiments, the text based items in anannotation may include multiple versions for different languages. Somesuch embodiments may include description strings 134 embedded in an XMLdocument or in a separate file or database.

The user interface generator 126 may use all of the items in theannotated hierarchical data type definition 128 to create various userinterfaces. In addition to structuring the user interface based on thehierarchy, the descriptive names, help prompts, and other such items maybe used to annotate user interface components.

The user interface components may be text boxes, drop down lists, radiobuttons, check boxes, and other components that may be placed on a userinterface. Such components may be labeled using the descriptive namesand other text based descriptors.

The user interface components may be selected based on the acceptablevalues defined in the type definition. For example, an element that hasa text type may have a text box input component selected. In anotherexample, a drop down list may be selected for types that have apredefined set of options. For a Boolean type, a radio button orcheckbox may be selected.

In many embodiments, a set of predefined user interfaces 125 may beassociated with the data type definition 128. The predefined userinterfaces 125 may include graphical user interfaces that may be richuser interfaces that may include graphics, typography, and other designelements.

In some embodiments, a user interface generator 126 may identifygraphical design elements from a predefined user interface and applysome or all of the graphical design elements to an automaticallygenerated portion of a user interface.

The predefined user interfaces 125 may be defined in XML or some otherlanguage that may be received by the user interface generator 126 andused to generate an actual user interface.

The user interface generator 126 may generate data collection userinterfaces 136 and data display user interfaces 138. A data collectionuser interface 136 may include user interface components that mayreceive input from a user to collect data. A data display user interface138 may present one or more instances of a data type. A data displayuser interface 138 may or may not have a mechanism for collecting inputfrom a user.

In some embodiments, the application 124 may be a standalone applicationthat operates on the device 102 and generates user interfaces that maybe displayed on the user interface display devices 118. In otherembodiments, the application 124 may create user interfaces that may bedisplayed on a remote device using a browser or other remote accessmechanism. When a browser is used, the user interfaces may be definedusing Hyper Text Markup Language (HTML) or other similar technologiessuch that the user interface may be rendered on a browser. In anotherremote technology, the user interfaces may be presented on a remotedevice using remote presentation technologies, sometimes known as remotedesktop or remote terminal technologies.

In one example of the application 124, the application 124 may monitorvarious client devices 146 that may be accessed over a network 144. Theapplication 124 may be able to gather performance information about theclients 146 using an automated data collector 142 and store data abouteach client 146 in database 140.

In such an example embodiment, a data type definition may be createdthat may have many different data types that may represent differenttypes of clients, different configurations of the clients, software andhardware aspects of the clients, and many other data types. Such anembodiment may also include a mechanism for creating and managingtrouble tickets that may be received by a help desk, among other things.Such an example may be discussed in embodiments 400, 500, and 600presented later in this specification.

In some embodiments, the annotated type definition 150 may be stored ina remote server 148 and may be referenced by an application 124 on thedevice 102. In such an embodiment, the application 124 may be adistributed application.

FIG. 2 is a flowchart illustration of an embodiment 200 showing a methodfor creating a user interface. Embodiment 200 is an example of a methodthat may be performed by an automated user interface generator, such asthe user interface generator 126 of embodiment 100.

Other embodiments may use different sequencing, additional or fewersteps, and different nomenclature or terminology to accomplish similarfunctions. In some embodiments, various operations or set of operationsmay be performed in parallel with other operations, either in asynchronous or asynchronous manner. The steps selected here were chosento illustrate some principles of operations in a simplified form.

Embodiment 200 illustrates one method for creating a user interfaceusing a hierarchical data type definition. When a data type is selectedthat does not have a predefined user interface, a predefined userinterface may be selected from the hierarchy of data types. Thedifferences between the predefined user interface and the selected datatype are identified, and the predefined user interface may be modifiedto include the different elements.

Embodiment 200 illustrates a method whereby an application may have manydata types for which a user interface may be generated, but may containfewer user interfaces that may be actually defined. The user interfacesthat may be defined may be used as templates and may be expanded toinclude other elements.

An annotated type definition may be received in block 202. In manyembodiments, the type definition may be a hierarchical type definitionwhere lower level types may inherit properties from higher level types.Each type may have several elements that may be parameters associatedwith the type, as well as various metadata about the type and theelements associated with the type.

In many embodiments, an element may have metadata that may includeidentification metadata. Identification metadata may include an elementname, short descriptor, long descriptor, help text, or other informationthat may be used to identify the element in a user interface. In someembodiments, such identification information may include a set of textstrings in different languages. When a language is selected, thosedescriptors in the language may be displayed.

The metadata may include parameter or value metadata. The value metadatamay define a data type for an element, which may be a primitive datatype such as Boolean, integer, real number, string, or other data type.In some cases, the element data type may be a complex data type that mayhave a set of string values, for example, or other data type that may beconstructed from the primitive data types.

The value metadata may include a range of values as well as defaultvalues for an element in some cases. The range of values may be used toconfigure a user interface component so that some initial value checkingmay be performed by the user interface.

A type may be identified in block 204 to display. The type may be acomplex data type that may have multiple elements.

If a predefined user interface exists in block 206, the user interfacemay be selected in block 208. If there are no extensions to the datatype in block 210, the predefined user interface may be presented to theuser in block 212.

If there are extensions to the data type in block 210, a set of elementsmay be identified in block 214 from the extensions. The set of elementsmay be processed later in the method at block 228 to create additionaluser interface components.

If the predefined user interface does not exist in block 206, the datatype hierarchy may be traversed in block 216 to attempt to identify apredefined user interface from another data type. The data typehierarchy may examine each data type between the selected data type anda base class in order and may select the first predefined user interfacethat may be detected.

In a hierarchical data type definition, the elements from each parentclass and data type may be inherited by the lower level data types. Insuch an embodiment, a predefined user interface for a higher level datatype may contain many of the elements for a lower level data type andmay be used as a starting point for an automatically generated userinterface for the lower level data type.

In other embodiments, the data type hierarchy may be traversed downwardsto identify a predefined user interface. Such a predefined userinterface may reference a child or grandchild data type from theselected data type, and may include more elements than may be found inthe selected data type. In such an embodiment, the automaticallygenerated user interface may have certain elements removed from thepredefined user interface.

If a predefined user interface is found in block 218, the predefineduser interface may be identified in block 220 and elements that are notfound in the predefined user interface but are found in the selecteddata type may be identified in block 222. The identified elements may bethose elements for which the predefined user interface may be modifiedto include. The process may continue in block 228.

If no predefined user interface is selected in block 218, a default userinterface may be used in block 224. A default user interface may includedefault settings, such as language, color palette, font, font size, orother parameters. In some cases, a default user interface may includegraphics and other design elements.

Because no predefined user interface is selected in block 218, all ofthe elements associated with a data type may be identified in block 226.The elements may include any elements that may be inherited from otherdata types or classes.

The selected elements in block 228 may be grouped or arranged. In somecases, the grouping may be defined by the hierarchy. In such cases, eachdata type or class from which a group of elements may be inherited maybe used as a grouping. The grouping may assist in creating a userinterface that may have elements gathered and arranged in meaningful orintuitive manners. Examples of grouped elements may be found inembodiments 400, 500, and 600 presented later in this specification.

For each group in block 230, a new user interface section may be createdin block 232. The section may be a collapsible section, tabbed section,or have some graphical differentiator to separate the elements for thegroup.

In cases where a predefined user interface is used, design elements fromthe predefined user interface may be identified in the predefined userinterface and applied to the newly created section. The design elementsmay include graphical images, color pallet, font, font size, layout,styles, and other elements.

For each element in the group in block 234, the metadata for the elementmay be analyzed in block 236. If the element is a hidden element inblock 238, the process may return to block 234.

If the element is not hidden in block 238, a user interface componentmay be selected in block 240, configured in block 241, and added to theuser interface in block 242. The user interface component may be a textbox, radio button, check box, drop down list, or other object that mayrepresent an element. The user interface component may be selected bymatching a data type of the element with a corresponding user interfacecomponent.

In some embodiments, the metadata associated with an element mayindicate which type of user interface component may be used fordisplaying the element. In embodiments where no such indication exists,a style definition for a predefined user interface or a default settingmay determine a user interface component for an element.

The user interface component may be configured in block 241, which mayconsist of applying labels or descriptors to the user interfacecomponent. The descriptors may be selected to match a selected languagefor the user interface. In some embodiments, a user interface componentmay have a help feature that may have a detailed description of theelement to assist a user. Such detailed description may be added to auser interface so that the use may view the detailed description onrequest.

The configuration of block 241 may also include defining limits for thevalues acceptable for the user interface component. When limits areincluded in a user interface component, the user interface may performinitial check of any value received from a user so that the value may bewithin a predefined set of values.

After processing each element in block 234, each group may be similarlyprocessed in block 230. After all groups are processed in block 230, theuser interface may be ready for presentation to a user in block 244.

FIG. 3 is a flowchart illustration of an embodiment 300 showing a methodfor populating user interface. Embodiment 300 is an example of a methodthat may be performed by an automated user interface generator, such asthe user interface generator 126 of embodiment 100, and may illustratehow a user interface may be populated with existing or default values.

Other embodiments may use different sequencing, additional or fewersteps, and different nomenclature or terminology to accomplish similarfunctions. In some embodiments, various operations or set of operationsmay be performed in parallel with other operations, either in asynchronous or asynchronous manner. The steps selected here were chosento illustrate some principles of operations in a simplified form.

A user interface may be presented in block 302.

If the user interface is a display-type user interface meant to presentinformation, such as the data display user interfaces 138 of embodiment100, the values to present may be gathered in block 306 and used topopulate the user interface with the values in block 308.

If the user interface is meant to gather information from a user inblock 304, and current values exist for the current instance of the datatype in block 310, those values may be gathered in block 312. If nocurrent values exist in block 310, the process may skip to block 314.

For each element in block 314, if a current value exists in block 316,the user interface component for that element may be populated with thatvalue in block 318. If a current value does not exist in block 316 and adefault value for the element exists in block 320, the component may bepopulated with the default value in block 322. If no default valueexists, the process may return to block 314.

Once all of the elements have their corresponding user interfacecomponents populated with existing or default values in blocks 314through 322, the data collection user interface may be used to receiveuser input in block 324. The user may interact with the user interfacein block 324 until the user is done in block 326. When the user is donein block 326, the user input may be stored in block 328.

FIG. 4 is a diagram illustration of an embodiment 400 showing an exampleof a hierarchy of data types. The data types described in embodiment 400are illustrated as user interfaces in embodiments 500 and 600.

The examples of embodiments 400, 500, and 600 are merely one example ofa hierarchical data type definition may be used to generate userinterfaces.

Embodiment 400 shows a tree 402 that may represent a hierarchy of datatypes associated with computers and other devices. The top level classmay be a device 404. Children of the device 404 may be a printer 406, aclient 408, and a server 410. Children of the server 410 may be opensource operating system 412 and proprietary operating system 414.

The proprietary operating system 414 may have children data types of a2007 version 416 and a 2010 version 418. The 2007 version 416 may havechildren data types of virtualized 420 and native 422.

The tree 402 may show a hierarchical set of data types where elementsassociated with each data type may be inherited by child data types.

The device 404 is illustrated as having elements 424, which may consistof “device ID”, “location”, and “owner”. These elements may be common toall child data types from the device 404.

The server 410 is illustration as having elements 426, which may consistof “function”, “Internet facing”, and “IP address”. The proprietaryoperating system 414 may have a single element 428 “license”. The 2007version 416 may have elements 420 that consist of “service pack” and“configured options”. Lastly, the virtualized 420 data type may haveelement 432 “host”.

FIG. 5 is a diagram illustration of an embodiment 500 showing an exampleuser interface that may be created from the hierarchical data type ofembodiment 400. Embodiment 500 illustrates a graphical user interfacethat may be created to collect data for the data type virtualized 420 ofembodiment 400.

The user interface 502 of embodiment 500 illustrates one form of agrouped user interface. In the case of embodiment 500, the elements ofeach data type may be presented in sections of the user interface thatmay be collapsed and expanded.

The user interface 502 illustrates several groups that correspond todata types, such as the device 504, server 506, operating system 508,2007 version 510, and virtualized 512. The groups for the device 504,2007 version 510, and virtualized 512 are illustrated as expanded, whilethe other groups are illustrated as collapsed. The collapse buttons 514,520, and 526 may be activated by a user to collapse the respectivegroup. Similarly, the expand buttons 516 and 518 may be used to expandthe respective group.

The device 504 group contains a single text box 506 that corresponds toa device ID element. In the elements 424 of embodiment 400, threeelements may be defined for the device 404, but only one of the elementsmay be displayed in the group of device 504. This may be because theother elements may be defined as hidden and therefore not displayed.

In the 2007 version 510 group, a drop down list 522 may be created torepresent the element “service pack” and several checkboxes 524 mayrepresent the “configured options” element 430. Similarly, thevirtualized 512 group may contain a text box 528 for the element “host”.

The user interface 502 may include buttons 530 to allow the user toeither save their changes or to cancel the operation.

The user interface 502 is illustrated as being populated with some data.Each of the text boxes 506 and 528 are displaying a value, as is thedrop down list 522 and the checkboxes 524.

FIG. 6 is a diagram illustration of an embodiment 600 showing an exampleuser interface that may be create from the hierarchical data type ofembodiment 400. Embodiment 600 illustrates a second graphical userinterface that may be created to collect data for the data typevirtualized 420 of embodiment 400.

The user interface 602 of embodiment 600 illustrates a second form of agrouped user interface. In the case of embodiment 600, the elements ofeach data type may be presented as tabbed portions of the user interface602. A user may select between each tab to display elements associatedwith the group and interact with the user interface controls for thoseelements.

Each tab 604, 606, 608, 610, and 612 may represent one of the data typesof device 404, server 410, proprietary operating system 412, 2007version 414, and virtualized 420, respectively. Tab 601 is illustratedas selected and the user interface components representing elementscorresponding with the 2007 version 614 are shown.

A drop down list 616 may represent the “service pack” element 430, andthe checkboxes 618 may represent the “configured options” element 430.

Embodiments 500 and 600 illustrate two types of user interfaces that maybe created using an automated user interface generator. In the case ofembodiment 500, a predefined user interface may be created for the 2007version data type and the elements of the virtualized data type may beadded to the existing user interface by merely adding another groupsection and the user interface controls corresponding to the elements ofthat data type.

Similarly, embodiment 600 may illustrate an embodiment where each tabmay represent a single data type. When one or more of the data types maynot have a predefined user interface, an automated user interfacegenerator may create a new tab representing the data type and addappropriate user interface components. In this manner, an existing userinterface may be easily expanded to include additional data types andadditional elements for a given data type.

The foregoing description of the subject matter has been presented forpurposes of illustration and description. It is not intended to beexhaustive or to limit the subject matter to the precise form disclosed,and other modifications and variations may be possible in light of theabove teachings. The embodiment was chosen and described in order tobest explain the principles of the invention and its practicalapplication to thereby enable others skilled in the art to best utilizethe invention in various embodiments and various modifications as aresuited to the particular use contemplated. It is intended that theappended claims be construed to include other alternative embodimentsexcept insofar as limited by the prior art.

1. A method performed on a computer processor, said method comprising:receiving an annotated type definition, said annotated type definitioncomprising a hierarchy of types and metadata about said types;identifying a first type for which to create a first user interface;determining that a predefined user interface does not exist for saidfirst type; identifying a set of related types for said first type, saidrelated types comprising a base class; examining said set of relatedtypes to identify a first predefined user interface for a second type,said second type being related to said first type; identifying a set ofelements contained in said first type and not a member of said secondtype; creating a set of user interface components based on said set ofelements; and presenting a new user interface comprising said firstpredefined user interface and said set of user interface components. 2.The method of claim 1 further comprising: populating said set of userinterface components with descriptors, said descriptors being containedin said annotated type definition.
 3. The method of claim 2 furthercomprising: determining a display language for said new user interface;and selecting said descriptors based on said display language.
 4. Themethod of claim 3 further comprising: presenting said set of userinterface components in a grouped fashion.
 5. The method of claim 4,said grouped fashion comprising creating a section in said new userinterface comprising at least a portion of said set of user interfacecomponents.
 6. The method of claim 5, said section comprising a tabbeddisplay.
 7. The method of claim 5, said section comprising a collapsibledisplay.
 8. The method of claim 1 further comprising: populating atleast one of said user interface components with a default value.
 9. Themethod of claim 1 further comprising: determining a current value for afirst element, said first element being one of said set of elements; andpopulating a first user interface component with said current value,said first user interface component representing said first element. 10.The method of claim 1 further comprising: identifying a plurality ofoptions for a first element; and populating a first user interfacecomponent with said plurality of options.
 11. The method of claim 1further comprising: determining that a first element is a hiddenelement; and not displaying a first user interface component related tosaid first element.
 12. A system comprising: a processor; a userinterface display; an application operable on said processor, saidapplication comprising: an annotated type definition, said annotatedtype definition comprising a hierarchy of types and metadata about saidtypes; a user interface generator that: identifies a first type forwhich to create a first user interface; determines that a firstpredefined user interface does not exist for said first type; identifiesa set of related types for said first type, said related typescomprising a base class; examines said set of related types to identifya second predefined user interface for a second type, said second typebeing related to said first type; identifies a set of elements containedin said first type and not a member of said second type; creates a setof user interface components based on said set of elements; and presentsa new user interface comprising said second predefined user interfaceand said set of user interface components on said user interfacedisplay.
 13. The system of claim 12, said annotated type definitionfurther comprising a descriptor a first element.
 14. The system of claim13, said annotated type definition further comprising a default valuefor said first element.
 15. The system of claim 14, said annotated typedefinition further comprising a hidden modifier for said first element,said user interface generator that further does not display a userinterface component related to said first element.
 16. The system ofclaim 15, said annotated type definition comprising a plurality ofgroupings for said elements, said user interface generator that furtherarranges said set of user interface components according to saidgroupings.
 17. The system of claim 16, said grouping being defined atleast in part by said hierarchy of types.
 18. A method performed on acomputer processor, said method comprising: receiving an annotated typedefinition, said annotated type definition comprising a hierarchy oftypes and metadata about said types, said metadata comprisingdescriptors for said types, a first default value for a first elementassociated with a first type; identifying said first type for which tocreate a first user interface; determining that a predefined userinterface does not exist for said first type; identifying a set ofrelated types for said first type, said related types comprising a baseclass and a second type, said second type being in said hierarchybetween said base class and said first type; examining said set ofrelated types to identify a first predefined user interface for saidsecond type; identifying a set of elements contained in said first typeand not a member of said second type; creating a set of user interfacecomponents based on said set of elements; and presenting a new userinterface comprising said first predefined user interface and said setof user interface components.
 19. The method of claim 18 furthercomprising: identifying said second type for which to create a seconduser interface; determining that said first user interface is apredefined user interface for said second type; and presenting saidfirst user interface.
 20. The method of claim 19 further comprising:identifying a current set of values for said first type; and populatingsaid new user interface with said current set of values.